package com.radar.io.radar346.DataType;

import cn.hutool.core.date.DateUtil;
import com.amazonaws.util.IOUtils;
import com.radar.common.ProductType;
import com.radar.io.radar346.DataParser;
import com.radar.utils.BitConverter;
import lombok.Data;
import lombok.Getter;
import org.python.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;

import java.io.*;
import java.nio.ByteBuffer;
import java.util.Date;

import java.util.Date;

@Data
public class STI {



    long    所属风暴体的序号 ;
    long 所属体扫的序号 ;
    boolean    是否新的风暴体 ;
    long 对应风暴组件数据偏移  ;
    long  风暴分量个数 ;
    long  风暴体序列号 ;
    float  最低仰角;
    float  最高仰角;
    float  顶高 ;
    float  底高 ;
    float  权重中心所在的高度 ;
    float  权重中心所在的距离;
    float  权重中心所在的方位 ;
    float  x轴 ;
    float  y轴 ;
    float  权重体积 ;
    float  含水量 ;
    float  最大反射率 ;
    float  最大反射率对应的高度 ;
    float  风暴体的移速 ;
    float  风暴体的移向 ;
    float  前一次体扫时风暴体的中心方位;
    float  前一次体扫时风暴体的中心距离 ;
    //备份
    float  备份1 ;
    float  备份2 ;
    //备份
    int  前一个体扫风暴中的序号 ;
    float  风暴现在的中心方位 ;
    float  风暴现在的中心距离 ;
    int  当前体扫风暴中的序号 ;
    float  风暴现在的中心方位1 ;
    float  风暴现在的中心距离1 ;

    int  预测的数据个数;
    Date 观测时间 ;


    public static ProductType productType(byte[] bytes, int index) {
        Long tm = readTm(bytes,  index );//观测时间
        Date date1 = new Date();
        date1.setTime(tm);
        System.err.println("------- L  " + DateUtil.format(date1 , "yyyy-MM-dd HH:mm:ss"));
        index+=18 ;

        int storm = BitConverter.toInt32(bytes, index);   //第二个数据   //包含的 Storm 的个数
        index+=4 ;
        long 暴体的序号 = Integer.toUnsignedLong(BitConverter.toInt32Inverse(bytes, index)); // 所属风暴体的序号
        index+=4 ;
        long 属体扫的序号 = Integer.toUnsignedLong(BitConverter.toInt32Inverse(bytes, index));  //所属体扫的序号
        index+=4 ;
        byte[] xx = getXx(bytes, 1, index);//是否新的风暴体

        index+=1 ;
        long 据偏移 = Integer.toUnsignedLong(BitConverter.toInt32Inverse(bytes, index));
        index+=4 ;
        long 风暴分量个数 = Integer.toUnsignedLong(BitConverter.toInt32Inverse(bytes, index));
        index+=4 ;
        short  风暴体序列号 =  BitConverter.toShort16(bytes,index);  //风暴体序列号
        index+=2 ;
        float  最低仰角 =readFloat(bytes, index);  // 风暴体对应的最低仰角，度
        index+=4 ;
        float  最高仰角 =readFloat(bytes, index);  // 风暴体对应的最高仰角，度
        index+=4 ;
        float  顶高 =readFloat(bytes, index);  // 风暴体的顶高,km
        index+=4 ;
        float  底高 =readFloat(bytes, index);  // 风暴体的底高,km
        index+=4 ;
        float  权重中心所在的高度 =readFloat(bytes, index);  // 风暴体质量权重中心所在的高度,km
        index+=4 ;
        float  权重中心所在的距离 =readFloat(bytes, index);  //风暴体质量权重中心所在的距离,km
        index+=4 ;
        float  方位角 =readFloat(bytes, index);  //风暴体质量权重中心方位角
        index+=4 ;
        float  x轴 =readFloat(bytes, index);  //风暴体质量权重中心x轴
        index+=4 ;
        float  y轴 =readFloat(bytes, index);  //风暴体质量权重中心Y轴
        index+=4 ;
        float  权重体积 =readFloat(bytes, index);  //风暴体质量权重体积
        index+=4 ;
        float  含水量 =readFloat(bytes, index);  //风暴体对应的垂直累积液态含水量
        index+=4 ;
        float  最大反射率 =readFloat(bytes, index);  //最大反射率
        index+=4 ;
        float  最大反射率对应的高度 =readFloat(bytes, index);  //最大反射率对应的高度
        index+=4 ;
        float  风暴体的移速 =readFloat(bytes, index);  //风暴体的移速,m/s
        index+=4 ;
        float  风暴体的移向 =readFloat(bytes, index);  //风暴体的移向,度
        index+=4 ;
        float  前一次体扫时风暴体的中心方位 =readFloat(bytes, index);  //前一次体扫时风暴体的中心方位，度
        index+=4 ;
        float  前一次体扫时风暴体的中心距离 =readFloat(bytes, index);  //前一次体扫时风暴体的中心距离，km
        index+=4 ;
        //备份
        index+=4 ;  //
        //备份
        index+=4 ;
        float  前一个体扫风暴中的序号 =readFloat(bytes, index); //与前一个体扫匹配的风暴体在前一个体扫风暴中的序号
        index+=4 ;
        float  风暴现在的中心方位 =readFloat(bytes, index); //风暴现在的中心方位，度
        index+=4 ;
        float  风暴现在的中心距离 =readFloat(bytes, index); //风暴现在的中心距离，km
        index+=4 ;
        float  当前体扫风暴中的序号 =readFloat(bytes, index); //当前体扫时匹配的风暴体在当前体扫风暴中的序号    //31的数据
        index+=4 ;



        float  预测的数据个数 =readFloat(bytes, index); //预测的数据个数
        index+=4 ;
        int 观测时间 = BitConverter.toInt32(bytes, index);  //观测时间
        index+=4 ;

        //在这里循环2 - 31 之间的数据
        for (int i=2  ; i<= storm ; i++ ) {
            DataParser.parSTI(bytes ,index );
        }


        return null;
    }

    public static float readFloat(byte[] bytes, int index) {
        if (bytes.length - index < 4) {
            throw new IllegalArgumentException(
                    "The length of the byte array must be at least 4 bytes for float.");
        }

        ByteBuffer buffer = ByteBuffer.wrap(bytes, index, 4);
        return buffer.getFloat();
    }

    public static long readUnsignedInt(byte[] bytes, int index) {
        if (bytes.length - index < 4) {
            throw new IllegalArgumentException(
                    "The length of the byte array must be at least 4 bytes for unsigned int.");
        }

        ByteBuffer buffer = ByteBuffer.wrap(bytes, index, 4);
        return buffer.getInt() & 0xFFFFFFFFL;
    }


    public static long readTm(byte[] bytes, int index) {
        ByteBuffer buffer = ByteBuffer.wrap(bytes, index, 18);
        return buffer.getLong();
    }


    /**
     *
     打开bz2文件
     */
    public static BZip2CompressorInputStream openBz2File(String filePath) throws IOException {
        FileInputStream fileInputStream = new FileInputStream(filePath);
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        BZip2CompressorInputStream bz2InputStream = new BZip2CompressorInputStream(bufferedInputStream);
        return bz2InputStream;
    }




    public static byte[] parseBz2File(String filePath) throws IOException, FileNotFoundException {
        FileInputStream fis = new FileInputStream(filePath);
        BZip2CompressorInputStream bz2InputStream = new BZip2CompressorInputStream(fis);

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = bz2InputStream.read(buffer)) != -1) {
            byteArrayOutputStream.write(buffer, 0, bytesRead);
        }
        bz2InputStream.close();
        fis.close();
        return byteArrayOutputStream.toByteArray();
    }




    /**
     *解压
     */
    public static void extractFile(BZip2CompressorInputStream bz2InputStream, String outputPath) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream(outputPath);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        IOUtils.copy(bz2InputStream, bufferedOutputStream);
        bufferedOutputStream.close();
    }

    /**
     * 关闭
     */
    public static void closeBz2File(BZip2CompressorInputStream bz2InputStream) throws IOException {
        bz2InputStream.close();
    }


    public static void main(String[] args) throws IOException {
        int index = 0 ;
        byte[] bytes = parseBz2File("D:\\work\\guorong\\国天资料\\202311\\20231111\\STI\\20230613_174038.00.049.005.0.bz2");
        byte[] tou = getXx(bytes, 2, index);
        short shortValue = (short) (tou[0] << 8 | tou[1]);
        index+=2 ;
        byte[] gm = getXx(bytes, 20, index);
        String s = new String(gm,"GBK");
        System.out.println(s);
        index = 1266 ;
        byte[] tm = getXx(bytes, 18, index);
        String s1 = new String(tm ,"UTF-8");
        System.out.println(s1);
    }
//
    public static byte[]  getXx(byte[] bytes, int read, int start){
        // 分离时间字段
        byte[] readByte = new byte[read];
        System.arraycopy(bytes, start, readByte, 0, read);
     return  readByte ;
    }
//    long    所属风暴体的序号 ;
//    long 所属体扫的序号 ;
//    boolean    是否新的风暴体 ;
//    long 对应风暴组件数据偏移  ;
//    long  风暴分量个数 ;
//    long  风暴体序列号 ;
//    float  最低仰角;
//    float  最高仰角;
//    float  顶高 ;
//    float  底高 ;
//    float  权重中心所在的高度 ;
//    float  权重中心所在的距离;
//    float  权重中心所在的方位 ;
//    float  x轴 ;
//    float  y轴 ;
//    float  权重体积 ;
//    float  含水量 ;
//    float  最大反射率 ;
//    float  最大反射率对应的高度 ;
//    float  风暴体的移速 ;
//    float  风暴体的移向 ;
//    float  前一次体扫时风暴体的中心方位;
//    float  前一次体扫时风暴体的中心距离 ;
//    //备份
//    float  备份1 ;
//    float  备份2 ;
//    //备份
//    float  前一个体扫风暴中的序号 ;
//    float  风暴现在的中心方位 ;
//    float  风暴现在的中心距离 ;
//    float  当前体扫风暴中的序号 ;
//    float  预测的数据个数;
//    int 观测时间 ;
//
//

}
